home *** CD-ROM | disk | FTP | other *** search
/ SGI Developer Toolbox 6.1 / SGI Developer Toolbox 6.1 - Disc 4.iso / public / Xprof / xmeasure / tstgfx.c < prev    next >
C/C++ Source or Header  |  1994-08-01  |  20KB  |  849 lines
  1. /*==================================================================
  2.  *      File :          tstgfx.c
  3.  *      Package:        Xmeasure
  4.  * 
  5.  *      Author :        Aloke Gupta.
  6.  *
  7.  *  (C) Copyright 1992, Aloke Gupta.
  8.  *  All rights granted to University of Illinois Board of Regents.
  9.  *==================================================================*/
  10.  
  11. #include "perf.h"
  12.  
  13. #define POLYOBJECTS 8     /* Number of objects for Poly requests */
  14.  
  15. #define XINC_LINE 64
  16. #define YINC_LINE 64
  17.  
  18. #define XINC_RECT  1
  19. #define YINC_RECT  2
  20.  
  21. #define XOFFSET_RECT 2
  22. #define YOFFSET_RECT 2
  23.  
  24. /* Shared variables */
  25. static int i;
  26. static XPoint     *points;
  27. static XSegment   *segments;
  28. static XRectangle *rectangles;
  29. static XArc      *arcs;
  30. static XImage      *image;
  31. static Pixmap       pixmap;
  32. static Pixmap      *pixmaps;
  33. static GC       mygc;
  34. static GC      *GCs;
  35. static XGCValues   gcval;
  36. static unsigned long gcmask;
  37.  
  38. /* ====================================================================== */
  39.  
  40. int   CreatePixmap(xd, xp)   
  41. XD *xd;
  42. XParams *xp;
  43. {
  44.     int width = 16, height = 16;
  45.     for (i = 0; i < xp->itns; i++) {
  46.     pixmaps[i] = XCreatePixmap(xd->display, xd->window, width, height,
  47.             DefaultDepth(xd->display, xd->screen ));
  48.     if (pixmaps[i] == NULL) {
  49.     /*
  50.         fprintf(stderr, "CreatePixmap: Can't allocate %dth pixmap", i);
  51.     */
  52.         xp->itns = i;
  53.         break;
  54.     }
  55.     }
  56. }
  57. int i_CreatePixmap(xd, xp)   
  58. XD *xd;
  59. XParams *xp;
  60. {
  61.     pixmaps = (Pixmap *) malloc (xp->itns * sizeof(Pixmap));
  62. }
  63. int c_CreatePixmap(xd, xp)   
  64. XD *xd;
  65. XParams *xp;
  66. {
  67.     for (i = 0; i < xp->itns; i++)
  68.     XFreePixmap(xd->display, pixmaps[i]);
  69.     free(pixmaps);
  70. }
  71.  
  72. /* ====================================================================== */
  73.  
  74. int   FreePixmap(xd, xp)     
  75. XD *xd;
  76. XParams *xp;
  77. {
  78.     for (i = 0; i < xp->itns; i++)
  79.     XFreePixmap(xd->display, pixmaps[i]);
  80. }
  81. int i_FreePixmap(xd, xp)     
  82. XD *xd;
  83. XParams *xp;
  84. {
  85.     int width = 8, height = 8;
  86.     pixmaps = (Pixmap *) malloc (xp->itns * sizeof(Pixmap));
  87.     for (i = 0; i < xp->itns; i++) {
  88.     pixmaps[i] = XCreatePixmap(xd->display, xd->window, width, height,
  89.             DefaultDepth(xd->display, xd->screen ));
  90.     if (pixmaps[i] == NULL) {
  91.         /*
  92.         fprintf(stderr, "Can't allocate %dth pixmap", i);
  93.         */
  94.         xp->itns = i;
  95.         break;
  96.     }
  97.     }
  98. }
  99. int c_FreePixmap(xd, xp)     
  100. XD *xd;
  101. XParams *xp;
  102. {
  103.     free(pixmaps);
  104. }
  105.  
  106. /* ====================================================================== */
  107.  
  108. int   CreateGC(xd, xp)       
  109. XD *xd;
  110. XParams *xp;
  111. {
  112.     for (i = 0; i < xp->itns; i++)
  113.     GCs[i] = XCreateGC(xd->display, xd->window, gcmask, &gcval);
  114. }
  115.  
  116. int i_CreateGC(xd, xp)       
  117. XD *xd;
  118. XParams *xp;
  119. {
  120.     GCs = (GC *) malloc(xp->itns * sizeof(GC));
  121.     gcmask = GCFunction | GCLineWidth | GCLineStyle | GCFillStyle;
  122.     gcval.function   = GXxor;
  123.     gcval.line_width = 1;
  124.     gcval.line_style = LineOnOffDash;
  125.     gcval.fill_style = FillStippled;
  126.  
  127. }
  128.  
  129. int c_CreateGC(xd, xp)       
  130. XD *xd;
  131. XParams *xp;
  132. {
  133.     for (i = 0; i < xp->itns; i++)
  134.     XFreeGC(xd->display, GCs[i]);
  135.     free(GCs);
  136. }
  137.  
  138. /* ====================================================================== */
  139. /* Note: XChangeGC measurement is meaningless since Xlib has a cache for GC
  140.      attributes.
  141.  */
  142. int   ChangeGC(xd, xp)       
  143. XD *xd;
  144. XParams *xp;
  145. {
  146.     for (i = 0; i < xp->itns; i++) {
  147.     if (i % 2) gcval.function = GXcopy;
  148.     else       gcval.function   = GXxor;
  149.     XChangeGC(xd->display, mygc, gcmask, &gcval);
  150.     }
  151. }
  152.  
  153. int i_ChangeGC(xd, xp)       
  154. XD *xd;
  155. XParams *xp;
  156. {
  157.     mygc = XCreateGC(xd->display, xd->window, 0, 0);
  158.     gcmask = GCFunction | GCLineWidth  | GCLineStyle | GCFillStyle |
  159.               GCForeground | GCBackground;
  160.     gcval.function   = GXxor;
  161.     gcval.line_width = 1;
  162.     gcval.line_style = LineOnOffDash;
  163.     gcval.fill_style = FillStippled;
  164.     gcval.foreground = WhitePixel(xd->display, xd->screen);
  165.     gcval.background = BlackPixel(xd->display, xd->screen);
  166. }
  167.  
  168. int c_ChangeGC(xd, xp)       
  169. XD *xd;
  170. XParams *xp;
  171. {
  172.     XFreeGC(xd->display, mygc);
  173. }
  174.  
  175. /* ====================================================================== */
  176.  
  177. int   CopyGC(xd, xp)         
  178. XD *xd;
  179. XParams *xp;
  180. {
  181.     for (i = 0; i < xp->itns; i++)
  182.     XCopyGC(xd->display, GCs[0], gcmask, GCs[1]);
  183. }
  184.  
  185. int i_CopyGC(xd, xp)         
  186. XD *xd;
  187. XParams *xp;
  188. {    
  189.     GCs = (GC *) malloc(2 * sizeof(GC)); 
  190.     GCs[0] = XCreateGC(xd->display, xd->window, 0, 0);
  191.     GCs[1] = XCreateGC(xd->display, xd->window, 0, 0);
  192.     gcmask = ~0;    /* Worst case: Copy all the attributes */
  193.  
  194.     gcmask = GCFunction | GCLineWidth  | GCLineStyle | GCFillStyle |
  195.               GCForeground | GCBackground;
  196. }
  197.  
  198. int c_CopyGC(xd, xp)         
  199. XD *xd;
  200. XParams *xp;
  201. {
  202.     XFreeGC(xd->display, GCs[0]);
  203.     XFreeGC(xd->display, GCs[1]);
  204.     free(GCs);
  205. }
  206.  
  207. /* ====================================================================== */
  208.  
  209. int   SetDashes(xd, xp)      
  210. XD *xd;
  211. XParams *xp;
  212. {
  213.     static char dash2[] = {6, 3};
  214.     static char dash4[] = {9, 3, 3, 3};
  215.  
  216.     for (i = 0; i < xp->itns; i++) {
  217.     if (i % 2) XSetDashes(xd->display, mygc, 0, dash2, 2);
  218.     else       XSetDashes(xd->display, mygc, 0, dash4, 4);
  219.     }
  220. }
  221. int i_SetDashes(xd, xp)      
  222. XD *xd;
  223. XParams *xp;
  224. {   mygc = XCreateGC(xd->display, xd->window, 0, 0); }
  225. int c_SetDashes(xd, xp)      
  226. XD *xd;
  227. XParams *xp;
  228. {   XFreeGC(xd->display, mygc); }
  229.  
  230. /* ====================================================================== */
  231. static XRectangle crect4[4];
  232.  
  233. int   SetClipRectangles(xd, xp)
  234. XD *xd;
  235. XParams *xp;
  236. {
  237.     for (i = 0; i < xp->itns; i++) {
  238.     if (i % 2)
  239.          XSetClipRectangles(xd->display, mygc, 0, 0, crect4, 2, Unsorted);
  240.     else XSetClipRectangles(xd->display, mygc, 0, 0, crect4, 4, Unsorted);
  241.     }
  242. }
  243.  
  244. int i_SetClipRectangles(xd, xp)
  245. XD *xd;
  246. XParams *xp;
  247. {
  248.     mygc = XCreateGC(xd->display, xd->window, 0, 0);
  249.     for (i = 0; i < 4; i++) {
  250.     crect4[i].x     = DISPWIDTH  / (i + 1);
  251.     crect4[i].y     = DISPHEIGHT / (i + 1);
  252.     crect4[i].width  = DISPWIDTH  / (i + 1);
  253.     crect4[i].height = DISPHEIGHT / (i + 1);
  254.     }
  255. }
  256.  
  257. int c_SetClipRectangles(xd, xp)
  258. XD *xd;
  259. XParams *xp;
  260. {   XFreeGC(xd->display, mygc); }
  261.  
  262. /* ====================================================================== */
  263.  
  264. int   FreeGC(xd, xp)         
  265. XD *xd;
  266. XParams *xp;
  267. {
  268.     for (i = 0; i < xp->itns; i++)
  269.     XFreeGC(xd->display, GCs[i]);
  270. }
  271.  
  272. int i_FreeGC(xd, xp)         
  273. XD *xd;
  274. XParams *xp;
  275. {
  276.     GCs = (GC *) malloc(xp->itns * sizeof(GC));
  277.     for (i = 0; i < xp->itns; i++)
  278.     GCs[i] = XCreateGC(xd->display, xd->window, 0, 0);
  279. } 
  280.  
  281. int c_FreeGC(xd, xp)         
  282. XD *xd;
  283. XParams *xp;
  284. {
  285.     free(GCs);
  286. }
  287.  
  288. /* ====================================================================== */
  289. /* ClearArea: Sizepair => (width, height)     */
  290. /*           size     => area = width * height       */
  291.  
  292. int   ClearArea(xd, xp)      
  293. XD *xd;
  294. XParams *xp;
  295. {
  296.     int width, height;
  297.  
  298.     width    = xp->sizepair->s1;
  299.     height   = xp->sizepair->s2;
  300.     xp->size = width * height; 
  301.  
  302.     for (i = 0; i < xp->itns; i++)
  303.     XClearArea(xd->display, xd->window, 0, 0, width, height, True);
  304. }
  305.  
  306. int i_ClearArea(xd, xp)      
  307. XD *xd;
  308. XParams *xp;
  309. {
  310.     XFillRectangle(xd->display, xd->window, xd->gc, 0, 0,
  311.             DISPWIDTH, DISPHEIGHT);
  312.     xp->size = xp->sizepair->s1 * xp->sizepair->s2;
  313. }
  314.  
  315. int c_ClearArea(xd, xp)      
  316. XD *xd;
  317. XParams *xp;
  318. {
  319. }
  320.  
  321. /* ====================================================================== */
  322. /* CopyArea: Sizepair => (width, height)             */
  323. /*          size     => area = width * height        */
  324. /* The code here only measures the time taken to copy from pixmap to window */
  325.  
  326. int   CopyArea(xd, xp)       
  327. XD *xd;
  328. XParams *xp;
  329. {
  330.     int width, height;
  331.     int dst_x = 0, dst_y = 0;
  332.  
  333.     width  = xp->sizepair->s1;
  334.     height = xp->sizepair->s2;
  335.     for (i = 0; i < xp->itns; i++) {
  336.     XCopyArea(xd->display, pixmap, xd->window, xd->gc, 0, 0,
  337.             width, height, dst_x, dst_y);
  338.     if (height < DISPHEIGHT / 2)
  339.         dst_y += height;
  340.     else dst_y ++;
  341.     if ((dst_y + height) > DISPHEIGHT) {
  342.         dst_y %= DISPHEIGHT;
  343.         dst_x ++;
  344.         if ((dst_x + width ) > DISPWIDTH )
  345.         dst_x %= DISPWIDTH;
  346.     }
  347.     }
  348. }
  349.  
  350. int i_CopyArea(xd, xp)       
  351. XD *xd;
  352. XParams *xp;
  353. {
  354.     int width, height;
  355.  
  356.     width    = xp->sizepair->s1;
  357.     height   = xp->sizepair->s2;
  358.     xp->size = width * height;
  359.     RandomFill(xd, xp);
  360.     pixmap   = XCreatePixmap(xd->display, xd->window, width, height,
  361.             DefaultDepth(xd->display, xd->screen ));
  362.     XCopyArea(xd->display, xd->window, pixmap, xd->gc, 0, 0,
  363.             width, height, 0, 0);
  364. }
  365.  
  366. int c_CopyArea(xd, xp)       
  367. XD *xd;
  368. XParams *xp;
  369. {
  370.     XFreePixmap(xd->display, pixmap);
  371.     XClearWindow(xd->display, xd->window);
  372. }
  373.  
  374. /* ====================================================================== */
  375. /* CopyPlane: Sizepair => (width, height)                */
  376. /*            size     => area = width * height          */
  377.  
  378. int   CopyPlane(xd, xp)      
  379. XD *xd;
  380. XParams *xp;
  381. {
  382.     int width, height;
  383.     int dst_x = 0, dst_y = 0;
  384.  
  385.     width  = xp->sizepair->s1;
  386.     height = xp->sizepair->s2;
  387.     for (i = 0; i < xp->itns; i++) {
  388.     XCopyPlane(xd->display, pixmap, xd->window, xd->gc, 0, 0,
  389.             width, height, dst_x, dst_y, 1);
  390.     if (height < DISPHEIGHT / 2)
  391.         dst_y += height;
  392.     else dst_y ++;
  393.     if ((dst_y + height) > DISPHEIGHT) {
  394.         dst_y %= DISPHEIGHT;
  395.         dst_x ++;
  396.         if ((dst_x + width ) > DISPWIDTH )
  397.         dst_x %= DISPWIDTH;
  398.     }
  399.     }
  400. }
  401.  
  402. int i_CopyPlane(xd, xp)      
  403. XD *xd;
  404. XParams *xp;
  405. {
  406.     int width, height;
  407.  
  408.     width    = xp->sizepair->s1;
  409.     height   = xp->sizepair->s2;
  410.     xp->size = width * height;
  411.     RandomFill(xd, xp);
  412.     pixmap   = XCreatePixmap(xd->display, xd->window, width, height, 1);
  413. }
  414.  
  415. int c_CopyPlane(xd, xp)      
  416. XD *xd;
  417. XParams *xp;
  418. {
  419.     XFreePixmap(xd->display, pixmap);
  420.     XClearWindow(xd->display, xd->window);
  421. }
  422.  
  423. /* ====================================================================== */
  424. /* PolyPoint: Sizepair => (0, 0) */
  425.  
  426. int   PolyPoint(xd, xp)      
  427. XD *xd;
  428. XParams *xp;
  429. {
  430.     for (i = 0; i < xp->itns; i++)
  431.     XDrawPoints(xd->display, xd->window, xp->gc, 
  432.         points, (int) xp->numobjs, CoordModeOrigin);
  433. }
  434.  
  435. int i_PolyPoint(xd, xp)
  436. XD *xd;
  437. XParams *xp;
  438. {
  439.     xp->size = 0;
  440.     xp->numobjs = POLYOBJECTS;
  441.     points = (XPoint *) malloc(xp->numobjs * sizeof(XPoint) );
  442.  
  443.     for (i = 0; i < xp->numobjs; i++) {
  444.         points[i].x = rand() % DISPWIDTH;
  445.         points[i].y = rand() % DISPHEIGHT;
  446.     }
  447. }
  448.  
  449. int c_PolyPoint(xd, xp)
  450. XD *xd;
  451. XParams *xp;
  452. {
  453.     free(points);
  454. }
  455.  
  456. /* ====================================================================== */
  457. /* PolyLine: Sizepair => (length, 0) */
  458.  
  459. int   PolyLine(xd, xp)
  460. XD *xd;
  461. XParams *xp;
  462. {
  463.     for (i = 0; i < xp->itns; i++)
  464.         XDrawLines(xd->display,xd->window, xp->gc, points,
  465.             (int) xp->numobjs, CoordModeOrigin);
  466. }
  467.  
  468. int i_PolyLine(xd, xp) 
  469. XD *xd;
  470. XParams *xp;
  471. {
  472.     int xoffset = XINC_LINE / 2;
  473.     int yoffset = YINC_LINE / 2;
  474.     int xdir=1, ydir=1;
  475.  
  476.     xp->size = xp->sizepair->s1;    /* Length of line */
  477.     xp->numobjs = POLYOBJECTS;        /* Number of objects per request */
  478.     points = (XPoint *) malloc((xp->numobjs + 1 )* sizeof(XPoint));
  479.  
  480.     for (i = 0; i < xp->numobjs; i+=2) {
  481.         points[i].x   = xoffset ;
  482.         points[i].y   = yoffset ;
  483.  
  484.         points[i+1].x = xoffset + (xdir * xp->size);
  485.         points[i+1].y = yoffset + (ydir * YINC_LINE);
  486.  
  487.     /* Now set xoffset and yoffset for next computation */
  488.     yoffset += ydir * YINC_LINE;
  489.     if ((yoffset >= (DISPHEIGHT - YINC_LINE) ) || (yoffset <= YINC_LINE)) {
  490.         /* y has hit an extreme. */
  491.         ydir    *= -1;
  492.         xoffset += xdir * 2 * xp->size;/* Move away from previous drawing */
  493.  
  494.         if ( (xoffset >= (DISPWIDTH - XINC_LINE - xp->size)) ||
  495.          (xoffset <= XINC_LINE) )        {
  496.         xdir   *= -1;
  497.         xoffset+=xdir * 2 * xp->size;/*undo the last change to xoffset*/
  498.         if (xoffset <= (XINC_LINE + xp->size) )
  499.             xdir *= -1;
  500.         }
  501.     }
  502.     }
  503. }
  504.  
  505. int c_PolyLine(xd, xp) 
  506. XD *xd;
  507. XParams *xp;
  508. {
  509.     free(points);
  510. }
  511.  
  512. /* ====================================================================== */
  513. /* PolySegment: Sizepair => (length, 0) */
  514.  
  515. int   PolySegment(xd, xp)    
  516. XD *xd;
  517. XParams *xp;
  518. {
  519.     for (i = 0; i < xp->itns; i++) 
  520.     XDrawSegments(xd->display,xd->window, xp->gc,
  521.         segments, (int) xp->numobjs);
  522. }
  523. int i_PolySegment(xd, xp)    
  524. XD *xd;
  525. XParams *xp;
  526. {
  527.     int xoffset = XINC_LINE / 2;
  528.     int yoffset = YINC_LINE / 2;
  529.     int xdir=1, ydir=1;
  530.  
  531.     xp->size = xp->sizepair->s1;
  532.     xp->numobjs = POLYOBJECTS;
  533.     segments = (XSegment *) malloc((xp->numobjs + 1 )* sizeof(XSegment));
  534.  
  535.     for (i = 0; i < xp->numobjs; i++) {
  536.         segments[i].x1 = xoffset ;
  537.         segments[i].y1 = yoffset ;
  538.  
  539.         segments[i].x2 = xoffset + (xdir * xp->size);
  540.         segments[i].y2 = yoffset + (ydir * YINC_LINE);
  541.  
  542.     /* Now set xoffset and yoffset for next computation */
  543.     yoffset += ydir * YINC_LINE;
  544.     if ((yoffset >= (DISPHEIGHT - YINC_LINE) ) || (yoffset <= YINC_LINE)) {
  545.         /* y has hit an extreme. */
  546.         ydir    *= -1;
  547.         xoffset += xdir * 2 * xp->size;/* Move away from previous drawing */
  548.  
  549.         if ( (xoffset >= (DISPWIDTH - XINC_LINE - xp->size)) ||
  550.          (xoffset <= XINC_LINE) )        {
  551.         xdir   *= -1;
  552.         xoffset+=xdir * 2 * xp->size;/*undo the last change to xoffset*/
  553.         if (xoffset <= (XINC_LINE + xp->size) )
  554.             xdir *= -1;
  555.         }
  556.     }
  557.     }
  558. }
  559.  
  560. int c_PolySegment(xd, xp)    
  561. XD *xd;
  562. XParams *xp;
  563. {
  564.     free(segments);
  565. }
  566.  
  567. /* ====================================================================== */
  568. /* PolyRectangle: Sizepair => (width, height)             */
  569. /*           size     => perimeter = 2 * (width + height)    */
  570.  
  571. int   PolyRectangle(xd, xp)  
  572. XD *xd;
  573. XParams *xp;
  574. {
  575.     for (i = 0; i < xp->itns; i++)
  576.     XDrawRectangles(xd->display, xd->window, xp->gc,
  577.         rectangles, (int) xp->numobjs);
  578. }
  579.  
  580. int i_PolyRectangle(xd, xp)  
  581. XD *xd;
  582. XParams *xp;
  583. {
  584.     int xoffset = XOFFSET_RECT;
  585.     int yoffset = YOFFSET_RECT;
  586.     int xdir = 1, ydir = 1;
  587.     int width, height;
  588.  
  589.     width    = xp->sizepair->s1;
  590.     height    = xp->sizepair->s2;
  591.     xp->size    = 2 * (width + height);
  592.     xp->numobjs = POLYOBJECTS;
  593.     rectangles  = (XRectangle *) malloc (xp->numobjs * sizeof(XRectangle));
  594.  
  595.     for (i = 0; i < xp->numobjs; i++) {
  596.     rectangles[i].x      = xoffset;
  597.     rectangles[i].y      = yoffset;
  598.     rectangles[i].width  = width;
  599.     rectangles[i].height = height;
  600.  
  601.     yoffset += ydir * YINC_RECT;
  602.     xoffset += xdir * XINC_RECT;
  603.  
  604.     if ( (xoffset >= (DISPHEIGHT - width)) || (xoffset <= XINC_RECT) ) {
  605.         xdir *= -1;
  606.         xoffset += xdir * (XINC_RECT + 1);
  607.     }
  608.     if ( (yoffset >= (DISPHEIGHT - height)) || (yoffset <= YINC_RECT) ) {
  609.         ydir *= -1;
  610.         yoffset += ydir * (YINC_RECT + 1);
  611.     }
  612.     }
  613. }
  614.  
  615. int c_PolyRectangle(xd, xp)  
  616. XD *xd;
  617. XParams *xp;
  618. {
  619.     free(rectangles);
  620. }
  621.  
  622. /* ====================================================================== */
  623. /* PolyArc: Sizepair => (width, height)             */
  624. /*         size     => perimeter = 2 * (width + height)    */
  625. /* Fractional arcs are scaled from the data collected here    */
  626.  
  627. int   PolyArc(xd, xp)        
  628. XD *xd;
  629. XParams *xp;
  630. {
  631.     for (i = 0; i < xp->itns; i++)
  632.     XDrawArcs(xd->display, xd->window, xp->gc,
  633.         arcs, (int) xp->numobjs);
  634. }
  635.  
  636. int i_PolyArc(xd, xp)        
  637. XD *xd;
  638. XParams *xp;
  639. {
  640.     int xoffset = XOFFSET_RECT;
  641.     int yoffset = YOFFSET_RECT;
  642.     int xdir = 1, ydir = 1;
  643.     int width, height;
  644.  
  645.     width    = xp->sizepair->s1;
  646.     height    = xp->sizepair->s2;
  647.     xp->size    = 2 * (width + height);
  648.     xp->numobjs = POLYOBJECTS;
  649.     arcs    = (XArc *) malloc (xp->numobjs * sizeof(XArc));
  650.  
  651.     for (i = 0; i < xp->numobjs; i++) {
  652.     arcs[i].x      = xoffset;
  653.     arcs[i].y      = yoffset;
  654.     arcs[i].width  = width;
  655.     arcs[i].height = height;
  656.     arcs[i].angle1 = 0;
  657.     arcs[i].angle2 = 64 * 360;    /* Full circle */
  658.  
  659.     yoffset += ydir * YINC_RECT;
  660.     xoffset += xdir * XINC_RECT;
  661.  
  662.     if ( (xoffset >= (DISPHEIGHT - width)) || (xoffset <= XINC_RECT) ) {
  663.         xdir *= -1;
  664.         xoffset += xdir * (XINC_RECT + 1);
  665.     }
  666.     if ( (yoffset >= (DISPHEIGHT - height)) || (yoffset <= YINC_RECT) ) {
  667.         ydir *= -1;
  668.         yoffset += ydir * (YINC_RECT + 1);
  669.     }
  670.     }
  671. }
  672.  
  673. int c_PolyArc(xd, xp)        
  674. XD *xd;
  675. XParams *xp;
  676. {
  677.     free(arcs);
  678. }
  679.  
  680. /* ====================================================================== */
  681.  
  682. int   FillPoly(xd, xp)       
  683. XD *xd;
  684. XParams *xp;
  685. {
  686. }
  687. int i_FillPoly(xd, xp)       
  688. XD *xd;
  689. XParams *xp;
  690. {
  691. }
  692. int c_FillPoly(xd, xp)       
  693. XD *xd;
  694. XParams *xp;
  695. {
  696. }
  697.  
  698. /* ====================================================================== */
  699. /* PolyFillRectangle: Sizepair => (width, height)     */
  700. /*               size     => area = width * height    */
  701.  
  702. int   PolyFillRectangle(xd, xp)
  703. XD *xd;
  704. XParams *xp;
  705. {
  706.     for (i = 0; i < xp->itns; i++)
  707.     XFillRectangles(xd->display, xd->window, xp->gc,
  708.         rectangles, (int) xp->numobjs);
  709. }
  710. int i_PolyFillRectangle(xd, xp)
  711. XD *xd;
  712. XParams *xp;
  713. {
  714.     i_PolyRectangle(xd, xp);
  715.     xp->size = xp->sizepair->s1 * xp->sizepair->s2;
  716. }
  717. int c_PolyFillRectangle(xd, xp)
  718. XD *xd;
  719. XParams *xp;
  720. {
  721.     c_PolyRectangle(xd, xp);
  722. }
  723.  
  724. /* ====================================================================== */
  725. /* PolyFillArc: Sizepair => (width, height)     */
  726. /*        size     => area = width * height    */
  727. /* Fractional arcs are scaled from the data collected here    */
  728.  
  729. int   PolyFillArc(xd, xp)    
  730. XD *xd;
  731. XParams *xp;
  732. {
  733.     for (i = 0; i < xp->itns; i++)
  734.     XFillArcs(xd->display, xd->window, xp->gc, arcs, (int) xp->numobjs);
  735. }
  736.  
  737. int i_PolyFillArc(xd, xp)    
  738. XD *xd;
  739. XParams *xp;
  740. {
  741.     i_PolyArc(xd, xp);
  742.     xp->size = xp->sizepair->s1 * xp->sizepair->s2;
  743. }
  744.  
  745. int c_PolyFillArc(xd, xp)    
  746. XD *xd;
  747. XParams *xp;
  748. {
  749.     c_PolyArc(xd, xp);
  750. }
  751.  
  752. /* ====================================================================== */
  753. /* PutImage: Sizepair => (width, height)     */
  754. /*          size     => area = width * height       */
  755.  
  756. int   PutImage(xd, xp)       
  757. XD *xd;
  758. XParams *xp;
  759. {
  760.     int width, height;
  761.     int dst_x = 0, dst_y = 0;
  762.  
  763.     width  = xp->sizepair->s1;
  764.     height = xp->sizepair->s2;
  765.     for (i = 0; i < xp->itns; i++) {
  766.     XPutImage(xd->display, xd->window, xp->gc, image,
  767.             0, 0, dst_x, dst_y, width, height);
  768.     dst_x ++; dst_y ++;
  769.     if ((dst_x + width ) > DISPWIDTH ) dst_x = 0;
  770.     if ((dst_y + height) > DISPHEIGHT) dst_y = 0;
  771.     }
  772. }
  773.  
  774. int i_PutImage(xd, xp)       
  775. XD *xd;
  776. XParams *xp;
  777. {
  778.     xp->size = xp->sizepair->s1 * xp->sizepair->s2;
  779.     RandomFill(xd, xp);
  780.     /* Create an image */
  781.     image = XGetImage(xd->display, xd->window, 0, 0,
  782.             DISPWIDTH, DISPHEIGHT, ~0, ZPixmap);
  783. }
  784.  
  785. int c_PutImage(xd, xp)       
  786. XD *xd;
  787. XParams *xp;
  788. {
  789.     XDestroyImage(image);
  790.     XClearWindow(xd->display, xd->window);
  791. }
  792.  
  793. /* ====================================================================== */
  794. /* GetImage: Sizepair => (width, height)     */
  795. /*          size     => area = width * height       */
  796.  
  797. int   GetImage(xd, xp)       
  798. XD *xd;
  799. XParams *xp;
  800. {
  801.     int width, height;
  802.     int dst_x = 0, dst_y = 0;
  803.  
  804.     width  = xp->sizepair->s1;
  805.     height = xp->sizepair->s2;
  806.     for (i = 0; i < xp->itns; i++) {
  807.     XDestroyImage(image);
  808.     image =XGetImage(xd->display, xd->window, 
  809.             0, 0, width, height, ~0, ZPixmap);
  810.     dst_x ++; dst_y ++;
  811.     if ((dst_x + width ) > DISPWIDTH ) dst_x = 0;
  812.     if ((dst_y + height) > DISPHEIGHT) dst_y = 0;
  813.     }
  814. }
  815.  
  816. int i_GetImage(xd, xp)       
  817. XD *xd;
  818. XParams *xp;
  819. {
  820.     i_PutImage(xd, xp);
  821. }
  822.  
  823. int c_GetImage(xd, xp)       
  824. XD *xd;
  825. XParams *xp;
  826. {
  827.     XClearWindow(xd->display, xd->window);
  828. }
  829.  
  830. /* ====================================================================== */
  831. /* The following is a convenience function for filling the window with junk */
  832. #define NUMPOINTS 100
  833.  
  834. RandomFill (xd, xp)
  835. XD *xd;
  836. XParams *xp;
  837. {
  838.     points = (XPoint *) malloc (NUMPOINTS * sizeof(XPoint));
  839.     for (i = 0; i < NUMPOINTS; i ++) {
  840.     points[i].x = rand() % DISPWIDTH;
  841.     points[i].y = rand() % DISPHEIGHT;
  842.     }
  843.     XDrawPoints(xd->display, xd->window, xp->gc,
  844.     points, NUMPOINTS, CoordModeOrigin);
  845.     XDrawLines(xd->display, xd->window, xp->gc, 
  846.     points, NUMPOINTS, CoordModeOrigin);
  847.     free(points);
  848. }
  849.